package com.kx.talk.controller;

import com.alibaba.fastjson.JSONObject;
import com.kx.base.controller.BaseController;
import com.kx.base.dto.push.MessageDTO;
import com.kx.base.result.R;
import com.kx.base.util.SnowFlakeUtil;
import com.kx.base.vo.UserVO;
import com.kx.talk.client.PushClient;
import com.kx.talk.dto.*;
import com.kx.talk.pojo.FriendGroup;
import com.kx.talk.service.FriendService;
import com.kx.talk.vo.FriendRequestAddVO;
import com.kx.talk.vo.FriendVO;
import com.kx.talk.vo.PolicyVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

/**
 * @Author Sun
 * @Date 2021/7/28 10:46
 */
@RestController
@RequestMapping("kx/friend")
public class FriendController extends BaseController {
    @Autowired
    private FriendService friendService;

    @Autowired
    private PushClient pushClient;

    @Resource
    private SnowFlakeUtil snowFlakeUtil;

    /**
     * 开通好友服务的接口
     * 好友模块的数据从何而来
     */
    @PostMapping("start")
    public R start() {
        //需要userid，注册到数据库的friendbase表里。
        Long userId = userId();
        int result = friendService.insertFriendBase(userId);
        if (result > 0) {
            return R.ok(200, "好友服务开通成功");
        } else {
            return R.error(500, "好友服务开通失败");
        }
    }

    /**
     * 展示好友策略
     */
    @GetMapping("policies")
    public R showPolicies() {
        List<PolicyVO> policyVOS = friendService.selectPolicies();
        return R.ok(200, "查询成功").setResult("policies", policyVOS);
    }

    /**
     * 修改添加好友的策略
     */
    @PostMapping("policy")
    public R setPolicy(@RequestBody PolicyDTO policyDTO) {
        //获取用户id
        Long userId = userId();
        //获取策略id
        Integer id = policyDTO.getId();
        String question = policyDTO.getQuestion();
        String answer = policyDTO.getAnswer();
        String password = policyDTO.getPassword();
        //修改数据库
        int result = friendService.updatePolicyByUid(userId, id, question, answer, password);
        if (result > 0) {
            return R.ok(200, "修改成功");
        } else {
            return R.error(500, "修改失败");
        }
    }

    /**
     * 添加好友的方法
     * 张三添加李四为好友
     */
    @PostMapping("add")
    public R addFriend(@RequestBody AddFriendDTO addFriendDTO) {
        //当前用户的id
        Long userId = userId();
        //想要添加用户的id
        Long wantId = addFriendDTO.getWantId();
        String message = addFriendDTO.getMessage();
        Integer groupId = addFriendDTO.getGroupId();
        int result = friendService.addFriend(userId, wantId, message, groupId);
        if (result == 0) {
            //添加失败
            return R.error(501, "添加失败");
        } else if (result == 1) {
            //添加成功
            //调用推送信息模块，推送信息
            MessageDTO messageDTO = new MessageDTO();
            messageDTO.setUid(wantId);
            messageDTO.setServiceId(1);
            JSONObject msg = new JSONObject();
            msg.put("message", user().getNickname() + "已经添加你为好友");
            msg.put("user", user());
            messageDTO.setMessage(msg.toJSONString());


            //RequestId全局唯一的，分布式调用别的模块保证接口的幂等性
            //所以需要使用雪花算法生成全局唯一id
            messageDTO.setRequestId(snowFlakeUtil.nextId());

            pushClient.pushWeb(messageDTO);
            return R.ok(200, "添加成功");
        } else if (result == 2) {
            //添加请求已发送，等待对方验证
            //调用推送信息模块，推送信息
            MessageDTO messageDTO = new MessageDTO();
            messageDTO.setUid(wantId);
            messageDTO.setServiceId(1);
            JSONObject msg = new JSONObject();
            msg.put("message", user().getNickname() + "请求添加你为好友");
            msg.put("user", user());
            msg.put("requestMsg", message);
            messageDTO.setMessage(msg.toJSONString());


            //RequestId全局唯一的，分布式调用别的模块保证接口的幂等性
            //所以需要使用雪花算法生成全局唯一id
            messageDTO.setRequestId(snowFlakeUtil.nextId());

            pushClient.pushWeb(messageDTO);
            return R.ok(201, "添加请求已经发送");
        } else {
            return R.error("未知异常");
        }
    }

    /**
     * 答复好友请求的接口
     */
    @PostMapping("askfor")
    public R askFor(@RequestBody AskForDTO askForDTO) {
        Long id = askForDTO.getId();
        Integer state = askForDTO.getState();
        Long groupId = askForDTO.getGroupId();
        Long userId = userId();
        //返回请求人的id
        Long resultUserId = friendService.askRequest(id, userId, state, groupId);
        if (resultUserId == null) {
            return R.error(500, "数据异常，请重新登录");
        }
        //推送消息给请求人，让请求人知道对方有没有同意添加好友
        MessageDTO messageDTO = new MessageDTO();
        messageDTO.setUid(resultUserId);
        messageDTO.setServiceId(1);
        messageDTO.setRequestId(snowFlakeUtil.nextId());
        JSONObject msg = new JSONObject();
        UserVO user = user();
        if (state == 1) {
            //同意添加好友
            msg.put("message", user.getNickname() + "同意添加你为好友");
        } else {
            //拒绝
            msg.put("message", user.getNickname() + "拒绝添加你为好友");
        }
        //也应该将被请求人的整个用户信息推送给请求添加好友者
        msg.put("user", user);
        messageDTO.setMessage(msg.toJSONString());
        //调用推送模块，推送消息
        pushClient.pushWeb(messageDTO);
        if (state == 1) {
            return R.ok(200, "同意成功");
        } else {
            return R.ok(201, "拒绝成功");
        }
    }

    /**
     * 查询所有的请求的接口
     */
    @PostMapping("request")
    public R findRequest(@RequestBody RequestDTO requestDTO) {
        //1、请求列表应该分页查询。
        //2、展示的是请求自己的请求。
        Long userId = userId();
        Integer lastItemId = requestDTO.getLastItemId();
        Integer pageSize = requestDTO.getPageSize();
        List<FriendRequestAddVO> friendRequestAddVOS = friendService.selectRequestByPage(userId, lastItemId, pageSize);
        return R.ok(200, "查询成功").setResult("friendRequestAdds", friendRequestAddVOS);
    }

    /**
     * 查询所有分组
     */
    @GetMapping("groups")
    public R findGroups() {
        Long userId = userId();
        //查询数据库
        List<FriendGroup> friendGroups = friendService.selectGroupsByUserId(userId);
        //返回数据
        return R.ok().setResult("friendGroups", friendGroups);
    }

    /**
     * 创建一个分组
     */
    @PostMapping("group")
    public R createGroup(@RequestBody CreateGroupDTO createGroupDTO) {
        String groupName = createGroupDTO.getGroupName();
        //获取当前用户的id
        Long userId = userId();
        //入库
        int result = friendService.createGroup(userId, groupName);
        //返回数据
        if (result == 0) {
            return R.error(501, "创建分组失败");
        } else if (result == 1) {
            return R.ok(200, "创建分组成功");
        } else if (result == 2) {
            return R.error(502, "组的数量已经达到上限");
        } else if (result == 3) {
            return R.error(503, "指定组已经存在");
        } else {
            return R.error("未知错误");
        }
    }

    /**
     * 给好友设置一个分组
     */
    @PostMapping("togroup")
    public R editFriendToGroup(@RequestBody ToGroupDTO toGroupDTO) {
        Long userId = userId();
        Long friendId = toGroupDTO.getFriendId();
        Integer groupId = toGroupDTO.getGroupId();
        int result = friendService.editFriendToGroup(userId, friendId, groupId);
        if (result == 0) {
            //失败
            return R.error(501, "修改失败");
        } else if (result == 1) {
            //成功
            return R.ok(200, "修改成功");
        } else if (result == 2) {
            //好友不存在
            return R.error(502, "好友不存在");
        } else if (result == 3) {
            //组不存在
            return R.error(503, "指定组不存在");
        } else {
            //未知异常
            return R.error(500, "未知异常");
        }
    }

    /**
     * 修改好友的备注
     */
    @PutMapping("markname")
    public R editFriendMarkName(@RequestBody MarkNameDTO markNameDTO) {
        Long friendId = markNameDTO.getFriendId();
        String markName = markNameDTO.getMarkName();
        Long userId = userId();
        int result = friendService.editFriendMarkName(userId, friendId, markName);
        if (result == 0) {
            return R.error(501, "修改失败");
        } else if (result == 1) {
            return R.ok(200, "修改成功");
        } else if (result == 2) {
            return R.error(502, "好友不存在");
        } else {
            return R.error(500, "未知异常");
        }
    }

    /**
     * 修改组的名称
     */
    @PutMapping("groupname")
    public R editGroupName(@RequestBody GroupNameDTO groupNameDTO) {
        Integer groupId = groupNameDTO.getGroupId();
        String groupName = groupNameDTO.getGroupName();
        Long userId = userId();
        int result = friendService.updateGroupName(userId, groupId, groupName);
        if (result == 0) {
            return R.error(501, "修改失败");
        } else if (result == 1) {
            return R.ok(200, "修改成功");
        } else if (result == 2) {
            return R.error(502, "好友分组不存在");
        } else {
            return R.error(500, "未知错误");
        }
    }

    /**
     * 删除一个分组
     */
    @DeleteMapping("group")
    public R delGroup(@RequestBody DelGroupDTO delGroupDTO) {
        Long userId = userId();
        Integer groupId = delGroupDTO.getGroupId();
        int result = friendService.delGroup(userId, groupId);
        if (result == 0) {
            return R.error(500, "删除失败");
        } else if (result == 1) {
            return R.ok(200, "删除成功");
        } else if (result == 2) {
            return R.error(501, "分组不存在");
        } else {
            return R.error(502, "未知错误");
        }
    }

    /**
     * 查询用户所有好友（展示好友列表）
     */
    @GetMapping("friends")
    public R findFriends(){
        Long userId = userId();
        List<FriendVO> friends = friendService.findFriends(userId);
        return R.ok(200,"查询成功").setResult("friends",friends);
    }
}
